/*!
 * \file CtaMocker.h
 * \project WonderTrader
 *
 * \author Wesley
 * \date 2020/03/30
 * 
 * \brief CTA模拟器头文件
 * 
 * \details 本文件定义了CTA模拟器CtaMocker类，用于回测环境下模拟CTA策略的执行。
 *          提供完整的CTA策略上下文接口实现，支持订单管理、持仓管理、资金管理、
 *          条件委托、信号处理等功能，为CTA策略回测提供完整的运行环境
 */
#pragma once
#include <sstream>
#include <atomic>
#include "HisDataReplayer.h"

#include "../Includes/FasterDefs.h"
#include "../Includes/ICtaStraCtx.h"
#include "../Includes/CtaStrategyDefs.h"
#include "../Includes/WTSDataDef.hpp"

#include "../Share/DLLHelper.hpp"
#include "../Share/StdUtils.hpp"
#include "../Share/fmtlib.h"

NS_WTP_BEGIN
class EventNotifier;
NS_WTP_END

USING_NS_WTP;

class HisDataReplayer;
class CtaStrategy;

const char COND_ACTION_OL = 0;	/*!< 开多 */
const char COND_ACTION_CL = 1;	/*!< 平多 */
const char COND_ACTION_OS = 2;	/*!< 开空 */
const char COND_ACTION_CS = 3;	/*!< 平空 */
const char COND_ACTION_SP = 4;	/*!< 直接设置仓位 */

/*!
 * \brief 条件委托结构体
 * \details 定义条件委托的各项参数，当市场数据满足设定条件时自动触发交易
 */
typedef struct _CondEntrust
{
	WTSCompareField _field;		/*!< 比较字段（价格、成交量等） */
	WTSCompareType	_alg;		/*!< 比较算法（大于、小于等） */
	double			_target;	/*!< 目标值 */

	double			_qty;		/*!< 委托数量 */

	char			_action;	/*!< 动作类型：0-开多,1-平多,2-开空,3-平空 */

	char			_code[MAX_INSTRUMENT_LENGTH];	/*!< 合约代码 */
	char			_usertag[32];					/*!< 用户标签 */

	/*!
	 * \brief 构造函数
	 * \details 初始化所有成员为0
	 */
	_CondEntrust()
	{
		memset(this, 0, sizeof(_CondEntrust));
	}

} CondEntrust;

typedef std::vector<CondEntrust>	CondList;		/*!< 条件委托列表类型 */
typedef faster_hashmap<std::string, CondList>	CondEntrustMap;	/*!< 条件委托映射表类型，按合约代码索引 */


/*!
 * \class CtaMocker
 * \brief CTA策略模拟器类
 * 
 * \details 该类实现了ICtaStraCtx（CTA策略上下文接口）和IDataSink（数据接收接口），
 *          为CTA策略在回测环境下提供完整的运行上下文。主要功能包括：
 *          - 策略生命周期管理（初始化、运行、结束）
 *          - 交易接口模拟（开仓、平仓、设置仓位）
 *          - 持仓管理和资金管理
 *          - 条件委托处理
 *          - 历史数据访问
 *          - 交易信号记录和统计
 *          - 策略日志输出
 * 
 * \note 该类是回测系统的核心组件，提供与实盘环境一致的策略接口
 */
class CtaMocker : public ICtaStraCtx, public IDataSink
{
public:
	/*!
	 * \brief 构造函数
	 * \details 创建CTA模拟器实例，初始化各项参数
	 * 
	 * \param replayer 历史数据回放器指针
	 * \param name 策略名称
	 * \param slippage 滑点设置（默认为0）
	 * \param persistData 是否持久化数据（默认为true）
	 * \param notifier 事件通知器指针（默认为NULL）
	 */
	CtaMocker(HisDataReplayer* replayer, const char* name, int32_t slippage = 0, bool persistData = true, EventNotifier* notifier = NULL);
	
	/*!
	 * \brief 析构函数
	 * \details 清理资源，保存数据，释放内存
	 */
	virtual ~CtaMocker();

private:
	/*!
	 * \brief 输出回测结果
	 * \details 将回测过程中的交易记录、持仓变化、资金曲线等数据输出到文件
	 */
	void	dump_outputs();
	
	/*!
	 * \brief 记录交易信号
	 * \details 记录策略产生的交易信号到日志文件
	 * 
	 * \param stdCode 合约代码
	 * \param target 目标仓位
	 * \param price 信号价格
	 * \param gentime 信号产生时间
	 * \param usertag 用户标签
	 */
	inline void log_signal(const char* stdCode, double target, double price, uint64_t gentime, const char* usertag = "");
	
	/*!
	 * \brief 记录交易明细
	 * \details 记录具体的开仓或平仓交易到交易日志
	 * 
	 * \param stdCode 合约代码
	 * \param isLong 是否多头
	 * \param isOpen 是否开仓
	 * \param curTime 交易时间
	 * \param price 交易价格
	 * \param qty 交易数量
	 * \param userTag 用户标签
	 * \param fee 手续费
	 * \param barNo K线编号
	 */
	inline void	log_trade(const char* stdCode, bool isLong, bool isOpen, uint64_t curTime, double price, double qty, const char* userTag = "", double fee = 0.0, uint32_t barNo = 0);
	
	/*!
	 * \brief 记录平仓明细
	 * \details 记录完整的开仓到平仓过程，包括盈亏统计
	 * 
	 * \param stdCode 合约代码
	 * \param isLong 是否多头
	 * \param openTime 开仓时间
	 * \param openpx 开仓价格
	 * \param closeTime 平仓时间
	 * \param closepx 平仓价格
	 * \param qty 交易数量
	 * \param profit 本次盈亏
	 * \param maxprofit 最大盈利
	 * \param maxloss 最大亏损
	 * \param totalprofit 总盈亏
	 * \param enterTag 开仓标签
	 * \param exitTag 平仓标签
	 * \param openBarNo 开仓K线编号
	 * \param closeBarNo 平仓K线编号
	 */
	inline void	log_close(const char* stdCode, bool isLong, uint64_t openTime, double openpx, uint64_t closeTime, double closepx, double qty,
		double profit, double maxprofit, double maxloss, double totalprofit = 0, const char* enterTag = "", const char* exitTag = "", uint32_t openBarNo = 0, uint32_t closeBarNo = 0);

	/*!
	 * \brief 更新浮动盈亏
	 * \details 根据最新价格更新持仓的浮动盈亏
	 * 
	 * \param stdCode 合约代码
	 * \param price 最新价格
	 */
	void	update_dyn_profit(const char* stdCode, double price);

	/*!
	 * \brief 执行设置仓位操作
	 * \details 根据目标仓位进行开仓或平仓操作的具体实现
	 * 
	 * \param stdCode 合约代码
	 * \param qty 目标数量
	 * \param price 价格
	 * \param userTag 用户标签
	 * \param bTriggered 是否由条件委托触发
	 */
	void	do_set_position(const char* stdCode, double qty, double price = 0.0, const char* userTag = "", bool bTriggered = false);
	
	/*!
	 * \brief 添加交易信号
	 * \details 将交易信号添加到信号队列中等待处理
	 * 
	 * \param stdCode 合约代码
	 * \param qty 目标数量
	 * \param userTag 用户标签
	 * \param price 价格
	 */
	void	append_signal(const char* stdCode, double qty, const char* userTag = "", double price = 0.0);

	/*!
	 * \brief 获取条件委托列表
	 * \details 获取指定合约的条件委托列表的引用
	 * 
	 * \param stdCode 合约代码
	 * \return CondList& 条件委托列表引用
	 */
	inline CondList& get_cond_entrusts(const char* stdCode);

public:
	/*!
	 * \brief 初始化CTA策略工厂
	 * \details 根据配置信息加载并初始化CTA策略工厂
	 * 
	 * \param cfg 策略配置信息
	 * \return bool 初始化是否成功
	 */
	bool	init_cta_factory(WTSVariant* cfg);
	
	/*!
	 * \brief 安装钩子函数
	 * \details 安装策略回调钩子，用于策略生命周期管理
	 */
	void	install_hook();
	
	/*!
	 * \brief 启用或禁用钩子
	 * \details 控制策略回调钩子的启用状态
	 * 
	 * \param bEnabled 是否启用（默认为true）
	 */
	void	enable_hook(bool bEnabled = true);
	
	/*!
	 * \brief 单步计算
	 * \details 执行一次策略计算，通常在回测过程中调用
	 * 
	 * \return bool 计算是否成功
	 */
	bool	step_calc();

public:
	//////////////////////////////////////////////////////////////////////////
	//IDataSink
	virtual void	handle_tick(const char* stdCode, WTSTickData* curTick) override;
	virtual void	handle_bar_close(const char* stdCode, const char* period, uint32_t times, WTSBarStruct* newBar) override;
	virtual void	handle_schedule(uint32_t uDate, uint32_t uTime) override;

	virtual void	handle_init() override;
	virtual void	handle_session_begin(uint32_t curTDate) override;
	virtual void	handle_session_end(uint32_t curTDate) override;

	virtual void	handle_replay_done() override;

	//////////////////////////////////////////////////////////////////////////
	//ICtaStraCtx
	virtual uint32_t id() { return _context_id; }

	// 回调接口
	/*!
	 * \brief 策略初始化回调
	 * \details 策略初始化时调用，用于设置策略的初始状态
	 */
	virtual void on_init() override;
	
	/*!
	 * \brief 交易时段开始回调
	 * \details 每个交易时段开始时调用
	 * 
	 * \param curTDate 当前交易日
	 */
	virtual void on_session_begin(uint32_t curTDate) override;
	
	/*!
	 * \brief 交易时段结束回调
	 * \details 每个交易时段结束时调用
	 * 
	 * \param curTDate 当前交易日
	 */
	virtual void on_session_end(uint32_t curTDate) override;
	
	/*!
	 * \brief Tick数据回调
	 * \details 收到新的Tick数据时调用
	 * 
	 * \param stdCode 合约代码
	 * \param newTick 新的Tick数据
	 * \param bEmitStrategy 是否触发策略计算
	 */
	virtual void on_tick(const char* stdCode, WTSTickData* newTick, bool bEmitStrategy = true) override;
	
	/*!
	 * \brief K线数据回调
	 * \details 收到新的K线数据时调用
	 * 
	 * \param stdCode 合约代码
	 * \param period 周期
	 * \param times 倍数
	 * \param newBar 新的K线数据
	 */
	virtual void on_bar(const char* stdCode, const char* period, uint32_t times, WTSBarStruct* newBar) override;
	
	/*!
	 * \brief 定时调度回调
	 * \details 按照定时任务的设置进行调度
	 * 
	 * \param curDate 当前日期
	 * \param curTime 当前时间
	 * \return bool 调度是否成功
	 */
	virtual bool on_schedule(uint32_t curDate, uint32_t curTime) override;
	
	/*!
	 * \brief 枚举持仓回调
	 * \details 枚举所有持仓并通过回调函数处理
	 * 
	 * \param cb 回调函数
	 */
	virtual void enum_position(FuncEnumCtaPosCallBack cb) override;

	virtual void on_tick_updated(const char* stdCode, WTSTickData* newTick) override;
	virtual void on_bar_close(const char* stdCode, const char* period, WTSBarStruct* newBar) override;
	virtual void on_calculate(uint32_t curDate, uint32_t curTime) override;


	//////////////////////////////////////////////////////////////////////////
	// 交易接口
	/*!
	 * \brief 开多仓
	 * \details 买入开仓操作
	 * 
	 * \param stdCode 合约代码
	 * \param qty 数量
	 * \param userTag 用户标签
	 * \param limitprice 限价（0表示市价）
	 * \param stopprice 止损价（0表示不设置）
	 */
	virtual void stra_enter_long(const char* stdCode, double qty, const char* userTag = "", double limitprice = 0.0, double stopprice = 0.0) override;
	
	/*!
	 * \brief 开空仓
	 * \details 卖出开仓操作
	 * 
	 * \param stdCode 合约代码
	 * \param qty 数量
	 * \param userTag 用户标签
	 * \param limitprice 限价（0表示市价）
	 * \param stopprice 止损价（0表示不设置）
	 */
	virtual void stra_enter_short(const char* stdCode, double qty, const char* userTag = "", double limitprice = 0.0, double stopprice = 0.0) override;
	
	/*!
	 * \brief 平多仓
	 * \details 卖出平仓操作
	 * 
	 * \param stdCode 合约代码
	 * \param qty 数量
	 * \param userTag 用户标签
	 * \param limitprice 限价（0表示市价）
	 * \param stopprice 止损价（0表示不设置）
	 */
	virtual void stra_exit_long(const char* stdCode, double qty, const char* userTag = "", double limitprice = 0.0, double stopprice = 0.0) override;
	
	/*!
	 * \brief 平空仓
	 * \details 买入平仓操作
	 * 
	 * \param stdCode 合约代码
	 * \param qty 数量
	 * \param userTag 用户标签
	 * \param limitprice 限价（0表示市价）
	 * \param stopprice 止损价（0表示不设置）
	 */
	virtual void stra_exit_short(const char* stdCode, double qty, const char* userTag = "", double limitprice = 0.0, double stopprice = 0.0) override;

	/*!
	 * \brief 获取持仓数量
	 * \details 获取指定合约的持仓数量，正数表示多头，负数表示空头
	 * 
	 * \param stdCode 合约代码
	 * \param bOnlyValid 是否只统计有效持仓（排除冻结部分）
	 * \param userTag 用户标签（空表示所有标签）
	 * \return double 持仓数量
	 */
	virtual double stra_get_position(const char* stdCode, bool bOnlyValid = false, const char* userTag = "") override;
	
	/*!
	 * \brief 设置目标仓位
	 * \details 设置指定合约的目标仓位，系统会自动计算需要的开平仓操作
	 * 
	 * \param stdCode 合约代码
	 * \param qty 目标仓位数量
	 * \param userTag 用户标签
	 * \param limitprice 限价（0表示市价）
	 * \param stopprice 止损价（0表示不设置）
	 */
	virtual void stra_set_position(const char* stdCode, double qty, const char* userTag = "", double limitprice = 0.0, double stopprice = 0.0) override;
	
	/*!
	 * \brief 获取最新价格
	 * \details 获取指定合约的最新价格
	 * 
	 * \param stdCode 合约代码
	 * \return double 最新价格
	 */
	virtual double stra_get_price(const char* stdCode) override;

	/*!
	 * \brief 获取当前交易日
	 * \details 获取当前回测的交易日期
	 * 
	 * \return uint32_t 交易日期（YYYYMMDD格式）
	 */
	virtual uint32_t stra_get_tdate() override;
	
	/*!
	 * \brief 获取当前日期
	 * \details 获取当前回测的日期
	 * 
	 * \return uint32_t 日期（YYYYMMDD格式）
	 */
	virtual uint32_t stra_get_date() override;
	
	/*!
	 * \brief 获取当前时间
	 * \details 获取当前回测的时间
	 * 
	 * \return uint32_t 时间（HHMM格式）
	 */
	virtual uint32_t stra_get_time() override;

	/*!
	 * \brief 获取资金数据
	 * \details 获取策略的资金相关数据
	 * 
	 * \param flag 数据类型标志（0-总盈亏，1-动态盈亏，2-手续费）
	 * \return double 资金数据
	 */
	virtual double stra_get_fund_data(int flag = 0) override;

	/*!
	 * \brief 获取首次开仓时间
	 * \details 获取指定合约的首次开仓时间
	 * 
	 * \param stdCode 合约代码
	 * \return uint64_t 首次开仓时间戳
	 */
	virtual uint64_t stra_get_first_entertime(const char* stdCode) override;
	
	/*!
	 * \brief 获取最后开仓时间
	 * \details 获取指定合约的最后一次开仓时间
	 * 
	 * \param stdCode 合约代码
	 * \return uint64_t 最后开仓时间戳
	 */
	virtual uint64_t stra_get_last_entertime(const char* stdCode) override;
	
	/*!
	 * \brief 获取最后平仓时间
	 * \details 获取指定合约的最后一次平仓时间
	 * 
	 * \param stdCode 合约代码
	 * \return uint64_t 最后平仓时间戳
	 */
	virtual uint64_t stra_get_last_exittime(const char* stdCode) override;
	
	/*!
	 * \brief 获取最后开仓价格
	 * \details 获取指定合约的最后一次开仓价格
	 * 
	 * \param stdCode 合约代码
	 * \return double 最后开仓价格
	 */
	virtual double stra_get_last_enterprice(const char* stdCode) override;
	
	/*!
	 * \brief 获取持仓均价
	 * \details 获取指定合约的持仓平均价格
	 * 
	 * \param stdCode 合约代码
	 * \return double 持仓平均价格
	 */
	virtual double stra_get_position_avgpx(const char* stdCode) override;
	
	/*!
	 * \brief 获取持仓盈亏
	 * \details 获取指定合约的持仓盈亏（浮动盈亏）
	 * 
	 * \param stdCode 合约代码
	 * \return double 持仓盈亏
	 */
	virtual double stra_get_position_profit(const char* stdCode) override;

	/*!
	 * \brief 获取详细持仓开仓时间
	 * \details 获取指定合约和用户标签的详细持仓开仓时间
	 * 
	 * \param stdCode 合约代码
	 * \param userTag 用户标签
	 * \return uint64_t 开仓时间戳
	 */
	virtual uint64_t stra_get_detail_entertime(const char* stdCode, const char* userTag) override;
	
	/*!
	 * \brief 获取详细持仓成本
	 * \details 获取指定合约和用户标签的详细持仓成本
	 * 
	 * \param stdCode 合约代码
	 * \param userTag 用户标签
	 * \return double 持仓成本
	 */
	virtual double stra_get_detail_cost(const char* stdCode, const char* userTag) override;
	
	/*!
	 * \brief 获取详细持仓盈亏
	 * \details 获取指定合约和用户标签的详细持仓盈亏
	 * 
	 * \param stdCode 合约代码
	 * \param userTag 用户标签
	 * \param flag 盈亏类型标志
	 * \return double 持仓盈亏
	 */
	virtual double stra_get_detail_profit(const char* stdCode, const char* userTag, int flag = 0) override;

	/*!
	 * \brief 获取合约信息
	 * \details 获取指定合约的商品信息
	 * 
	 * \param stdCode 合约代码
	 * \return WTSCommodityInfo* 商品信息指针
	 */
	virtual WTSCommodityInfo* stra_get_comminfo(const char* stdCode) override;
	
	/*!
	 * \brief 获取K线数据
	 * \details 获取指定合约的K线数据切片
	 * 
	 * \param stdCode 合约代码
	 * \param period 周期
	 * \param count 数量
	 * \param isMain 是否为主K线
	 * \return WTSKlineSlice* K线数据切片指针
	 */
	virtual WTSKlineSlice*	stra_get_bars(const char* stdCode, const char* period, uint32_t count, bool isMain = false) override;
	
	/*!
	 * \brief 获取Tick数据
	 * \details 获取指定合约的Tick数据切片
	 * 
	 * \param stdCode 合约代码
	 * \param count 数量
	 * \return WTSTickSlice* Tick数据切片指针
	 */
	virtual WTSTickSlice*	stra_get_ticks(const char* stdCode, uint32_t count) override;
	
	/*!
	 * \brief 获取最新Tick数据
	 * \details 获取指定合约的最新Tick数据
	 * 
	 * \param stdCode 合约代码
	 * \return WTSTickData* 最新Tick数据指针
	 */
	virtual WTSTickData*	stra_get_last_tick(const char* stdCode) override;

	/*!
	 * \brief 订阅Tick数据
	 * \details 订阅指定合约的Tick数据推送
	 * 
	 * \param stdCode 合约代码
	 */
	virtual void stra_sub_ticks(const char* stdCode) override;

	/*!
	 * \brief 记录信息日志
	 * \details 记录策略的信息级别日志
	 * 
	 * \param message 日志消息
	 */
	virtual void stra_log_info(const char* message) override;
	
	/*!
	 * \brief 记录调试日志
	 * \details 记录策略的调试级别日志
	 * 
	 * \param message 日志消息
	 */
	virtual void stra_log_debug(const char* message) override;
	
	/*!
	 * \brief 记录错误日志
	 * \details 记录策略的错误级别日志
	 * 
	 * \param message 日志消息
	 */
	virtual void stra_log_error(const char* message) override;

	/*!
	 * \brief 保存用户数据
	 * \details 保存策略的用户自定义数据
	 * 
	 * \param key 数据键
	 * \param val 数据值
	 */
	virtual void stra_save_user_data(const char* key, const char* val) override;

	/*!
	 * \brief 加载用户数据
	 * \details 加载策略的用户自定义数据
	 * 
	 * \param key 数据键
	 * \param defVal 默认值（当数据不存在时返回）
	 * \return const char* 数据值
	 */
	virtual const char* stra_load_user_data(const char* key, const char* defVal = "") override;

private:
	template<typename... Args>
	void log_debug(const char* format, const Args& ...args)
	{
		std::string s = fmt::sprintf(format, args...);
		stra_log_debug(s.c_str());
	}

	template<typename... Args>
	void log_info(const char* format, const Args& ...args)
	{
		std::string s = fmt::sprintf(format, args...);
		stra_log_info(s.c_str());
	}

	template<typename... Args>
	void log_error(const char* format, const Args& ...args)
	{
		std::string s = fmt::sprintf(format, args...);
		stra_log_error(s.c_str());
	}

protected:
	uint32_t			_context_id;		/*!< 策略上下文ID */
	HisDataReplayer*	_replayer;			/*!< 历史数据回放器指针 */

	uint64_t		_total_calc_time;		/*!< 总计算时间（纳秒） */
	uint32_t		_emit_times;			/*!< 总计算次数 */

	int32_t			_slippage;				/*!< 成交滑点（点数） */

	uint32_t		_schedule_times;		/*!< 调度次数 */

	std::string		_main_key;				/*!< 主K线数据键值 */

	typedef struct _KlineTag
	{
		bool			_closed;

		_KlineTag() :_closed(false){}

	} KlineTag;
	typedef faster_hashmap<std::string, KlineTag> KlineTags;
	KlineTags	_kline_tags;

	typedef faster_hashmap<std::string, double> PriceMap;
	PriceMap		_price_map;

	typedef struct _DetailInfo
	{
		bool		_long;
		double		_price;
		double		_volume;
		uint64_t	_opentime;
		uint32_t	_opentdate;
		double		_max_profit;
		double		_max_loss;
		double		_profit;
		char		_opentag[32];
		uint32_t	_open_barno;

		_DetailInfo()
		{
			memset(this, 0, sizeof(_DetailInfo));
		}
	} DetailInfo;

	typedef struct _PosInfo
	{
		double		_volume;
		double		_closeprofit;
		double		_dynprofit;
		uint64_t	_last_entertime;
		uint64_t	_last_exittime;
		double		_frozen;

		std::vector<DetailInfo> _details;

		_PosInfo()
		{
			_volume = 0;
			_closeprofit = 0;
			_dynprofit = 0;
			_frozen = 0;
		}

		inline double valid() const { return _volume - _frozen; }
	} PosInfo;
	typedef faster_hashmap<std::string, PosInfo> PositionMap;
	PositionMap		_pos_map;
	double	_total_closeprofit;

	typedef struct _SigInfo
	{
		double		_volume;
		std::string	_usertag;
		double		_sigprice;
		double		_desprice;
		bool		_triggered;
		uint64_t	_gentime;

		_SigInfo()
		{
			_volume = 0;
			_sigprice = 0;
			_desprice = 0;
			_triggered = false;
			_gentime = 0;
		}
	}SigInfo;
	typedef faster_hashmap<std::string, SigInfo>	SignalMap;
	SignalMap		_sig_map;

	std::stringstream	_trade_logs;
	std::stringstream	_close_logs;
	std::stringstream	_fund_logs;
	std::stringstream	_sig_logs;

	CondEntrustMap	_condtions;

	//�Ƿ��ڵ����еı��
	bool			_is_in_schedule;	//�Ƿ����Զ�������

	//�û�����
	typedef faster_hashmap<std::string, std::string> StringHashMap;
	StringHashMap	_user_datas;
	bool			_ud_modified;

	typedef struct _StraFundInfo
	{
		double	_total_profit;
		double	_total_dynprofit;
		double	_total_fees;

		_StraFundInfo()
		{
			memset(this, 0, sizeof(_StraFundInfo));
		}
	} StraFundInfo;

	StraFundInfo		_fund_info;

	typedef struct _StraFactInfo
	{
		std::string		_module_path;
		DllHandle		_module_inst;
		ICtaStrategyFact*	_fact;
		FuncCreateStraFact	_creator;
		FuncDeleteStraFact	_remover;

		_StraFactInfo()
		{
			_module_inst = NULL;
			_fact = NULL;
		}

		~_StraFactInfo()
		{
			if (_fact)
				_remover(_fact);
		}
	} StraFactInfo;
	StraFactInfo	_factory;

	CtaStrategy*	_strategy;
	EventNotifier*	_notifier;

	StdUniqueMutex	_mtx_calc;
	StdCondVariable	_cond_calc;
	bool			_has_hook;		//������Ϊ�����Ƿ����ù���
	bool			_hook_valid;	//���Ǹ����Ƿ����첽�ز�ģʽ��ȷ�������Ƿ����
	std::atomic<uint32_t>		_cur_step;	//��ʱ���������ڿ���״̬

	bool			_in_backtest;
	bool			_wait_calc;

	//�Ƿ�Իز����־û�
	bool			_persist_data;

	//tick�����б�
	faster_hashset<std::string> _tick_subs;
};